home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / games / 111 / nap.c < prev    next >
C/C++ Source or Header  |  1987-02-19  |  3KB  |  125 lines
  1. /* nap.c         Larn is copyrighted 1986 by Noah Morgan. */
  2. #ifndef TOS
  3. #include <signal.h>
  4. #include <sys/types.h>
  5. #ifdef SYSV
  6. #include <sys/times.h>
  7. #else
  8. #ifdef BSD
  9. #include <sys/timeb.h>
  10. #endif BSD
  11. #endif SYSV
  12. #endif TOS
  13. /*
  14.  *    routine to take a nap for n milliseconds
  15.  */
  16. #ifdef TOS
  17. nap(x)
  18.     {
  19.     lflush();
  20. }
  21. #else TOS
  22. nap(x)
  23.     register int x;
  24.     {
  25.     if (x<=0) return; /* eliminate chance for infinite loop */
  26.     lflush();
  27.     if (x > 999) sleep(x/1000); else napms(x);
  28.     }
  29.  
  30. #ifdef NONAP
  31. napms(x)    /* do nothing */
  32.     int x;
  33.     {
  34.     }
  35. #else NONAP
  36. #ifdef SYSV
  37. /*    napms - sleep for time milliseconds - uses times() */
  38. /* this assumes that times returns a relative time in 60ths of a second */
  39. /* this will do horrible things if your times() returns seconds! */
  40. napms(time)
  41.     int time;
  42.     {
  43.     long matchclock, times();
  44.     struct tms stats;
  45.  
  46.     if (time<=0) time=1; /* eliminate chance for infinite loop */
  47.     if ((matchclock = times(&stats)) == -1 || matchclock == 0)
  48.         return;    /* error, or BSD style times() */
  49.     matchclock += (time / 17);        /*17 ms/tic is 1000 ms/sec / 60 tics/sec */
  50.  
  51.     while(matchclock < times(&stats))
  52.         ;
  53.     }
  54.  
  55. #else not SYSV
  56. #ifdef BSD
  57. #ifdef SIGVTALRM
  58. /* This must be BSD 4.2!  */
  59. #include <sys/time.h>
  60. #define bit(_a) (1<<((_a)-1))
  61.  
  62. static  nullf()
  63.     {
  64.     }
  65.  
  66. /*    napms - sleep for time milliseconds - uses setitimer() */
  67. napms(time)
  68.     int time;
  69.     {
  70.     struct itimerval    timeout;
  71.     int     (*oldhandler) ();
  72.     int     oldsig;
  73.  
  74.     if (time <= 0) return;
  75.  
  76.     timerclear(&timeout.it_interval);
  77.     timeout.it_value.tv_sec = time / 1000;
  78.     timeout.it_value.tv_usec = (time % 1000) * 1000;
  79.  
  80.     oldsig = sigblock(bit(SIGALRM));
  81.     setitimer(ITIMER_REAL, &timeout, (struct itimerval *)0);
  82.     oldhandler = signal(SIGALRM, nullf);
  83.     sigpause(oldsig);
  84.     signal(SIGALRM, oldhandler);
  85.     sigsetmask(oldsig);
  86.     }
  87.  
  88. #else
  89. /*    napms - sleep for time milliseconds - uses ftime() */
  90.  
  91. static napms(time)
  92.     int time;
  93.     {
  94.     /* assumed to be BSD UNIX */
  95.     struct timeb _gtime;
  96.     time_t matchtime;
  97.     unsigned short matchmilli;
  98.     register struct timeb *tp = & _gtime;
  99.  
  100.     if (time <= 0) return;
  101.     ftime(tp);
  102.     matchmilli = tp->millitm + time;
  103.     matchtime  = tp->time;
  104.     while (matchmilli >= 1000)
  105.         {
  106.         ++matchtime;
  107.         matchmilli -= 1000;
  108.         }
  109.  
  110.     while(1)
  111.         {
  112.         ftime(tp);
  113.         if ((tp->time > matchtime) ||
  114.             ((tp->time == matchtime) && (tp->millitm >= matchmilli)))
  115.             break;
  116.         }
  117.     }
  118. #endif
  119. #else not BSD
  120. static napms(time) int time; {}    /* do nothing, forget it */
  121. #endif BSD
  122. #endif SYSV
  123. #endif NONAP
  124. #endif TOS
  125.